SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Mutator method</title>

</head>

Mutator method

</h1>

</header>

In <a href="Computer_science" title="Computer science">computer science</a>, a mutator method is a <a href="Method_(computer_science)" class="mw-redirect" title="Method (computer science)">method</a> used to control changes to a variable. They are also widely known as setter methods. Often a setter is accompanied by a getter, which returns the value of the private member variable. They are also known collectively as accessors.

The mutator method is most often used in <a href="Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a>, in keeping with the principle of <a href="Encapsulation_(computer_science)" class="mw-redirect" title="Encapsulation (computer science)">encapsulation</a>. According to this principle, member <a href="Variable_(programming)" class="mw-redirect" title="Variable (programming)">variables</a> of a <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a> are made private to hide and protect them from other code, and can only be modified by a public member function (the mutator method), which takes the desired new value as a parameter, optionally validates it, and modifies the private <a href="Member_variable" title="Member variable">member variable</a>. Mutator methods can be compared to <a href="Assignment_(computer_science)" title="Assignment (computer science)">assignment</a> <a href="Operator_overloading" title="Operator overloading">operator overloading</a> but they typically appear at different levels of the object hierarchy.

Mutator methods may also be used in non-object-oriented environments. In this case, a <a href="Pointer_(computer_programming)" title="Pointer (computer programming)">reference</a> to the variable to be modified is passed to the mutator, along with the new value. In this scenario, the compiler cannot restrict code from bypassing the mutator method and changing the variable directly. The responsibility falls to the <a href="Software_developer" class="mw-redirect" title="Software developer">developers</a> to ensure the variable is only modified through the mutator method and not modified directly.

In programming languages that support them, <a href="Property_(programming)" title="Property (programming)">properties</a> offer a convenient alternative without giving up the utility of encapsulation.

In the examples below, a fully implemented mutator method can also <a href="Data_validation" title="Data validation">validate</a> the input data or take further action such as triggering an <a href="Event_(computing)" title="Event (computing)">event</a>.

<div class="mw-heading mw-heading2"><h2 id="Implications">Implications</h2></div>

The alternative to defining mutator and accessor methods, or <a href="Property_(programming)" title="Property (programming)">property</a> blocks, is to give the <a href="Instance_variable" title="Instance variable">instance variable</a> some <a href="Information_hiding" title="Information hiding">visibility</a> other than private and access it directly from outside the objects. Much finer control of access rights can be defined using mutators and accessors. For example, a parameter may be made read-only simply by defining an accessor but not a mutator. The visibility of the two methods may be different; it is often useful for the accessor to be public while the mutator remains protected, package-private or internal.

The <a href="Block_(programming)" title="Block (programming)">block</a> where the mutator is defined provides an opportunity for <a href="Data_validation" title="Data validation">validation</a> or preprocessing of incoming data. If all external access is guaranteed to come through the mutator, then these steps cannot be bypassed. For example, if a date is represented by separate private <code>year</code>, <code>month</code> and <code>day</code> variables, then incoming dates can be split by the <code>setDate</code> mutator while for consistency the same private instance variables are accessed by <code>setYear</code> and <code>setMonth</code>. In all cases month values outside of 1 - 12 can be rejected by the same code.

Accessors conversely allow for synthesis of useful data representations from internal variables while keeping their structure encapsulated and hidden from outside modules. A monetary <code>getAmount</code> accessor may build a string from a numeric variable with the number of decimal places defined by a hidden <code>currency</code> parameter.

Modern programming languages often offer the ability to generate the <a href="Boilerplate_code" title="Boilerplate code">boilerplate</a> for mutators and accessors in a single line—as for example C#'s <code>public string Name { get; set; }</code> and Ruby's <code>attr_accessor :name</code>. In these cases, no code blocks are created for validation, preprocessing or synthesis. These simplified accessors still retain the advantage of encapsulation over simple public instance variables, but it is common that, as <a href="Agile_software_development" title="Agile software development">system designs progress</a>, the software is <a href="Software_maintenance" title="Software maintenance">maintained</a> and requirements change, the <a href="Data_integrity" title="Data integrity">demands on the data</a> become more sophisticated. Many automatic mutators and accessors eventually get replaced by separate blocks of code. The benefit of automatically creating them in the early days of the implementation is that the public interface of the class remains identical whether or not greater sophistication is added, requiring no extensive refactoring if it is.<a href="#cite_note-1">[1]</a>

Manipulation of parameters that have mutators and accessors from inside the class where they are defined often requires some additional thought. In the early days of an implementation, when there is little or no additional code in these blocks, it makes no difference if the private instance variable is accessed directly or not. As validation, <a href="Cross-validation_(statistics)" title="Cross-validation (statistics)">cross-validation</a>, <a href="Data_integrity" title="Data integrity">data integrity</a> checks, preprocessing or other sophistication is added, subtle <a href="Software_bug" title="Software bug">bugs</a> may appear where some internal access makes use of the newer code while in other places it is bypassed.

Accessor functions can be less efficient than directly fetching or storing data fields due to the extra steps involved,<a href="#cite_note-2">[2]</a> however such functions are often <a href="Inline_function" class="mw-redirect" title="Inline function">inlined</a> which eliminates the overhead of a function call.

<div class="mw-heading mw-heading2"><h2 id="Examples">Examples</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Assembly">Assembly</h3></div>

<div class="mw-highlight mw-highlight-lang-nasm mw-content-ltr" dir="ltr"><pre>student struct

age dd ?

student ends

</pre></div>

<div class="mw-highlight mw-highlight-lang-nasm mw-content-ltr" dir="ltr"><pre> .code

student_get_age proc object:DWORD

mov ebx, object

mov eax, student.age[ebx]

ret

student_get_age endp

student_set_age proc object:DWORD, age:DWORD

mov ebx, object

mov eax, age

mov student.age[ebx], eax

ret

student_set_age endp

</pre></div>

In file student.h:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>#ifndef _STUDENT_H

#define _STUDENT_H

struct student; /* opaque structure */

typedef struct student student;

student *student_new(int age, char *name);

void student_delete(student *s);

void student_set_age(student *s, int age);

int student_get_age(student *s);

char *student_get_name(student *s);

#endif

</pre></div>

In file student.c:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>#include <stdlib.h>

#include <string.h>

#include "student.h"

struct student {

int age;

char *name;

};

student *s = malloc(sizeof(student));

s->name = strdup(name);

s->age = age;

return s;

}

free(s->name);

free(s);

}

return s->age;

}

return s->name;

}

</pre></div>

In file main.c:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>#include <stdio.h>

#include "student.h"

int main(void) {

student *s = student_new(19, "Maurice");

char *name = student_get_name(s);

int old_age = student_get_age(s);

printf("%s's old age = %i\n", name, old_age);

student_set_age(s, 21);

int new_age = student_get_age(s);

printf("%s's new age = %i\n", name, new_age);

student_delete(s);

return 0;

}

</pre></div>

In file Makefile:

<div class="mw-highlight mw-highlight-lang-makefile mw-content-ltr" dir="ltr"><pre>all: out.txt; cat $<

out.txt: main; ./$< > $@

main: main.o student.o

main.o student.o: student.h

clean: ;$(RM) *.o out.txt main

</pre></div>

In file Student.h:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>#ifndef STUDENT_H

#define STUDENT_H

#include <string>

class Student {

public:

Student(const std::string& name);

const std::string& name() const;

void name(const std::string& name);

private:

std::string name_;

};

#endif

</pre></div>

In file Student.cpp:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>#include "Student.h"

Student::Student(const std::string& name) : name_(name) {

}

const std::string& Student::name() const {

return name_;

}

void Student::name(const std::string& name) {

name_ = name;

}

</pre></div>

This example illustrates the <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> idea of <a href="Property_(programming)#" title="Property (programming)">properties</a>, which are a special type of <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a> member. Unlike Java, no explicit methods are defined; a public 'property' contains the logic to handle the actions. Note use of the built-in (undeclared) variable <code>value</code>.

<div class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><pre>public class Student

{

private string name;

/// <summary>

/// Gets or sets student's name

/// </summary>

public string Name

{

get { return name; }

set { name = value; }

}

}

</pre></div>

In later C# versions (.NET Framework 3.5 and above), this example may be abbreviated as follows, without declaring the private variable <code>name</code>.

{

public string Name { get; set; }

}

</pre></div>

Using the abbreviated syntax means that the underlying variable is no longer available from inside the class. As a result, the <code>set</code> portion of the property must be present for assignment. Access can be restricted with a <code>set</code>-specific access modifier.

{

public string Name { get; private set; }

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Common_Lisp">Common Lisp</h3></div>

In <a href="Common_Lisp_Object_System" title="Common Lisp Object System">Common Lisp Object System</a>, slot specifications within class definitions may specify any of the <code>:reader</code>, <code>:writer</code> and <code>:accessor</code> options (even multiple times) to define reader methods, setter methods and accessor methods (a reader method and the respective <code>setf</code> method).<a href="#cite_note-defclass-3">[3]</a> Slots are always directly accessible through their names with the use of <code>with-slots</code> and <code>slot-value</code>, and the slot accessor options define specialized methods that use <code>slot-value</code>.<a href="#cite_note-defclass-accessors-4">[4]</a>

CLOS itself has no notion of properties, although the <a href="Common_Lisp_Object_System#Metaobject_Protocol" title="Common Lisp Object System">MetaObject Protocol</a> extension specifies means to access a slot's reader and writer function names, including the ones generated with the <code>:accessor</code> option.<a href="#cite_note-mop-slot-definitions-5">[5]</a>

The following example shows a definition of a student class using these slot options and direct slot access:

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defclass student ()

((name :initarg :name :initform "" :accessor student-name) ; student-name is setf'able

(birthdate :initarg :birthdate :initform 0 :reader student-birthdate)

(number :initarg :number :initform 0 :reader student-number :writer set-student-number)))

;; Example of a calculated property getter (this is simply a method)

(defmethod student-age ((self student))

(- (get-universal-time) (student-birthdate self)))

;; Example of direct slot access within a calculated property setter

(defmethod (setf student-age) (new-age (self student))

(with-slots (birthdate) self

(setf birthdate (- (get-universal-time) new-age))

new-age))

;; The slot accessing options generate methods, thus allowing further method definitions

(defmethod set-student-number :before (new-number (self student))

;; You could also check if a student with the new-number already exists.

(check-type new-number (integer 1 *)))

</pre></div>

<a href="D_(programming_language)" title="D (programming language)">D</a> supports a getter and setter function syntax. In version 2 of the language getter and setter class/struct methods should have the <code>@property</code> attribute.<a href="#cite_note-6">[6]</a><a href="#cite_note-7">[7]</a>

<div class="mw-highlight mw-highlight-lang-d mw-content-ltr" dir="ltr"><pre>class Student {

private char[] name_;

// Getter

return this.name_;

}

// Setter

@property char[] name(char[] name_in) {

return this.name_ = name_in;

}

}

</pre></div>

A <code>Student</code> instance can be used like this:

<div class="mw-highlight mw-highlight-lang-d mw-content-ltr" dir="ltr"><pre>auto student = new Student;

student.name = "David"; // same effect as student.name("David")

auto student_name = student.name; // same effect as student.name()

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Delphi">Delphi</h3></div>

This is a simple class in Delphi language which illustrates the concept of public property for accessing a private field.

<div class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" dir="ltr"><pre>interface

type

TStudent = class

strict private

FName: string;

procedure SetName(const Value: string);

public

/// <summary>

/// Get or set the name of the student.

/// </summary>

property Name: string read FName write SetName;

end;

// ...

implementation

procedure TStudent.SetName(const Value: string);

begin

FName := Value;

end;

end.

</pre></div>

In this example of a simple <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a> representing a student with only the name stored, one can see the <a href="Variable_(programming)" class="mw-redirect" title="Variable (programming)">variable</a> name is private, i.e. only visible from the Student class, and the "setter" and "getter" are public, namely the "<code>getName()</code>" and "<code>setName(name)</code>" methods.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public class Student {

private String name;

public String getName() {

return name;

}

public void setName(String newName) {

name = newName;

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="JavaScript">JavaScript</h3></div>

In this example constructor-function <code>Student</code> is used to create objects representing a student with only the name stored.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>function Student(name) {

var _name = name;

this.getName = function() {

return _name;

};

this.setName = function(value) {

_name = value;

};

}

</pre></div>

Or (using a deprecated way to define accessors in Web browsers):<a href="#cite_note-8">[8]</a>

this.__defineGetter__('name', function() {

return _name;

});

this.__defineSetter__('name', function(value) {

_name = value;

});

}

</pre></div>

Or (using prototypes for inheritance and <a href="ES6" class="mw-redirect" title="ES6">ES6</a> accessor syntax):

this._name = name;

}

Student.prototype = {

get name() {

return this._name;

},

set name(value) {

}

};

</pre></div>

Or (without using prototypes):

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>var Student = {

get name() {

return this._name;

},

}

};

</pre></div>

Or (using defineProperty):

}

Object.defineProperty(Student.prototype, 'name', {

get: function() {

return this._name;

},

set: function(value) {

}

});

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="ActionScript_3.0">ActionScript 3.0</h3></div>

<div class="mw-highlight mw-highlight-lang-actionscript mw-content-ltr" dir="ltr"><pre>package

{

public class Student

{

private var _name : String;

public function get name() : String

{

return _name;

}

public function set name(value : String) : void

{

_name = value;

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Objective-C">Objective-C</h3></div>

Using traditional Objective-C 1.0 syntax, with manual reference counting as the one working on <a href="GNUstep" title="GNUstep">GNUstep</a> on <a href="Ubuntu_version_history#1204" title="Ubuntu version history">Ubuntu 12.04</a>:

<div class="mw-highlight mw-highlight-lang-objc mw-content-ltr" dir="ltr"><pre>@interface Student : NSObject

{

NSString *_name;

}

- (NSString *)name;

- (void)setName:(NSString *)name;

@end

@implementation Student

- (NSString *)name

{

return _name;

}

{

[_name release];

_name = [name retain];

}

@end

</pre></div>

Using newer Objective-C 2.0 syntax as used in <a href="Mac_OS_X_10.6" class="mw-redirect" title="Mac OS X 10.6">Mac OS X 10.6</a>, <a href="IOS_4" title="IOS 4">iOS 4</a> and <a href="Xcode" title="Xcode">Xcode</a> 3.2, generating the same code as described above:

<div class="mw-highlight mw-highlight-lang-objc mw-content-ltr" dir="ltr"><pre>@interface Student : NSObject

@property (nonatomic, retain) NSString *name;

@end

@implementation Student

@synthesize name = _name;

@end

</pre></div>

And starting with <a href="OS_X_10.8" class="mw-redirect" title="OS X 10.8">OS X 10.8</a> and <a href="IOS_6" title="IOS 6">iOS 6</a>, while using <a href="Xcode" title="Xcode">Xcode</a> 4.4 and up, syntax can be even simplified:

<div class="mw-highlight mw-highlight-lang-objc mw-content-ltr" dir="ltr"><pre>@interface Student : NSObject

@property (nonatomic, strong) NSString *name;

@end

@implementation Student

//Nothing goes here and it's OK.

@end

</pre></div>

<div class="mw-highlight mw-highlight-lang-perl mw-content-ltr" dir="ltr"><pre>package Student;

sub new {

bless {}, shift;

}

sub set_name {

my $self = shift;

$self->{name} = $_[0];

}

sub get_name {

return $self->{name};

}

1;

</pre></div>

Or, using Class::Accessor

<div class="mw-highlight mw-highlight-lang-perl mw-content-ltr" dir="ltr"><pre>package Student;

use base qw(Class::Accessor);

__PACKAGE__->follow_best_practice;

Student->mk_accessors(qw(name));

1;

</pre></div>

Or, using the <a href="Moose_(Perl)" title="Moose (Perl)">Moose Object System</a>:

<div class="mw-highlight mw-highlight-lang-perl mw-content-ltr" dir="ltr"><pre>package Student;

use Moose;

# Moose uses the attribute name as the setter and getter, the reader and writer properties

# allow us to override that and provide our own names, in this case get_name and set_name

has 'name' => (is => 'rw', isa => 'Str', reader => 'get_name', writer => 'set_name');

1;

</pre></div>

PHP defines the "magic methods" <code>__get</code>and<code>__set</code> for properties of objects.<a href="#cite_note-9">[9]</a>

In this example of a simple <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a> representing a student with only the name stored, one can see the <a href="Variable_(programming)" class="mw-redirect" title="Variable (programming)">variable</a> name is private, i.e. only visible from the Student class, and the "setter" and "getter" is public, namely the <code>getName()</code> and <code>setName('name')</code> methods.

<div class="mw-highlight mw-highlight-lang-php mw-content-ltr" dir="ltr"><pre>class Student

{

private string $name;

/**

* @return string The name.

*/

public function getName(): string

{

return $this->name;

}

/**

* @param string $newName The name to set.

*/

public function setName(string $newName): void

{

$this->name = $newName;

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Python">Python</h3></div>

This example uses a Python class with one variable, a getter, and a setter.

<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre>class Student:

# Initializer

def __init__(self, name: str) -> None:

# An instance variable to hold the student's name

self._name = name

# Getter method

@property

def name(self):

return self._name

# Setter method

@name.setter

def name(self, new_name):

self._name = new_name

</pre></div>

<div class="mw-highlight mw-highlight-lang-pycon mw-content-ltr" dir="ltr"><pre>>>> bob = Student("Bob")

>>> bob.name

Bob

>>> bob.name = "Alice"

>>> bob.name

Alice

>>> bob._name = "Charlie" # bypass the setter

>>> bob._name # bypass the getter

Charlie

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Racket">Racket</h3></div>

In <a href="Racket_(programming_language)" title="Racket (programming language)">Racket</a>, the object system is a way to organize code that comes in addition to modules and units. As in the rest of the language, the object system has first-class values and lexical scope is used to control access to objects and methods.

<div class="mw-highlight mw-highlight-lang-racket mw-content-ltr" dir="ltr"><pre>#lang racket

(define student%

(class object%

(init-field name)

(define/public (get-name) name)

(define/public (set-name! new-name) (set! name new-name))

(super-new)))

(define s (new student% [name "Alice"]))

(send s get-name) ; => "Alice"

(send s set-name! "Bob")

</pre></div>

Struct definitions are an alternative way to define new types of values, with mutators being present when explicitly required:

<div class="mw-highlight mw-highlight-lang-racket mw-content-ltr" dir="ltr"><pre>#lang racket

(struct student (name) #:mutable)

(set-student-name! s "Bob")

(student-name s) ; => "Bob"

</pre></div>

In <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>, individual accessor and mutator methods may be defined, or the metaprogramming constructs <code>attr_reader</code> or <code>attr_accessor</code> may be used both to declare a private variable in a class and to provide either read-only or read-write public access to it respectively.

Defining individual accessor and mutator methods creates space for pre-processing or validation of the data

<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre>class Student

def name

@name

end

def name=(value)

@name=value

end

end

</pre></div>

Read-only simple public access to implied <code>@name</code> variable

<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre>class Student

attr_reader :name

end

</pre></div>

Read-write simple public access to implied <code>@name</code> variable

<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre>class Student

attr_accessor :name

end

</pre></div>

<div class="mw-highlight mw-highlight-lang-rust mw-content-ltr" dir="ltr"><pre>struct Student {

name: String,

}

impl Student {

fn name(&self) -> &String {

&self.name

}

fn name_mut(&mut self) -> &mut String {

&mut self.name

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Smalltalk">Smalltalk</h3></div>

<div class="mw-highlight mw-highlight-lang-smalltalk mw-content-ltr" dir="ltr"><pre> age: aNumber

" Set the receiver age to be aNumber if is greater than 0 and less than 150 "

(aNumber between: 0 and: 150)

ifTrue: [ age := aNumber ]

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Swift">Swift</h3></div>

<div class="mw-highlight mw-highlight-lang-swift mw-content-ltr" dir="ltr"><pre>class Student {

private var _name: String = ""

var name: String {

get {

return self._name

}

set {

self._name = newValue

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Visual_Basic_.NET">Visual Basic .NET</h3></div>

This example illustrates the VB.NET idea of properties, which are used in classes. Similar to C#, there is an explicit use of the <code>Get</code> and <code>Set</code> methods.

<div class="mw-highlight mw-highlight-lang-vbnet mw-content-ltr" dir="ltr"><pre>Public Class Student

Private _name As String

Public Property Name()

Get

Return _name

End Get

Set(ByVal value)

_name = value

End Set

End Property

End Class

</pre></div>

In VB.NET 2010, Auto Implemented properties can be utilized to create a property without having to use the Get and Set syntax. Note that a hidden variable is created by the compiler, called <code>_name</code>, to correspond with the Property <code>name</code>. Using another variable within the class named <code>_name</code> would result in an error. Privileged access to the underlying variable is available from within the class.

Public Property name As String

End Class

</pre></div>

<ul><li><a href="Property_(programming)" title="Property (programming)">Property (programming)</a></li>

<li><a href="Indexer_(programming)" title="Indexer (programming)">Indexer (programming)</a></li>

<li><a href="Immutable_object" title="Immutable object">Immutable object</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFStephen_Fuqua2009" class="citation web cs1">Stephen Fuqua (2009). <a rel="nofollow" class="external text" href="https://archive.today/20110513104930/http://www.safnet.com/writing/tech/archives/2009/04/automatic_prope.html">"Automatic Properties in C# 3.0"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.safnet.com/writing/tech/archives/2009/04/automatic_prope.html">the original</a> on 2011-05-13. Retrieved 2009-10-19.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite id="CITEREFTim_Lee1998" class="citation web cs1">Tim Lee (1998-07-13). <a rel="nofollow" class="external text" href="https://www.scribd.com/doc/53104779/Run-Time-Efficiency-of-Accessor-Functions">"Run Time Efficiency of Accessor Functions"</a>.</cite>

</li>

<li id="cite_note-defclass-3"><a href="#cite_ref-defclass_3-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.lispworks.com/documentation/HyperSpec/Body/m_defcla.htm">"CLHS: Macro DEFCLASS"</a>. Retrieved 2011-03-29.</cite>

</li>

<li id="cite_note-defclass-accessors-4"><a href="#cite_ref-defclass-accessors_4-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.lispworks.com/documentation/HyperSpec/Body/07_eb.htm">"CLHS: 7.5.2 Accessing Slots"</a>. Retrieved 2011-03-29.</cite>

</li>

<li id="cite_note-mop-slot-definitions-5"><a href="#cite_ref-mop-slot-definitions_5-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.lisp.org/mop/concepts.html#slot-definitions">"MOP: Slot Definitions"</a>. Retrieved 2011-03-29.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://dlang.org/function.html">"Functions - D Programming Language"</a>. Retrieved 2013-01-13.</cite>

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://dlang.org/dstyle.html">"The D Style"</a>. Retrieved 2013-02-01.</cite>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__">"Object.prototype.__defineGetter__() - JavaScript | MDN"</a>. developer.mozilla.org. Retrieved 2021-07-06.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.php.net/manual/en/language.oop5.overloading.php">"PHP: Overloading - Manual"</a>. www.php.net. Retrieved 2021-07-06.</cite>

</li>

</ol></div></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2024-10-06" href="https://en.wikipedia.org/wiki/?title=Mutator_method&oldid=1249641577">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>